home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / c / recio202.zip / rerr.c < prev    next >
C/C++ Source or Header  |  1994-05-05  |  6KB  |  144 lines
  1. /*****************************************************************************
  2.    MODULE: rerr.c
  3.   PURPOSE: recio error functions
  4. COPYRIGHT: (C) 1994 William Pierpoint
  5.  COMPILER: Borland C Version 3.1
  6.        OS: MSDOS Version 6.2
  7.   VERSION: 2.02
  8.   RELEASE: May 5, 1994
  9. *****************************************************************************/
  10.  
  11. #include <errno.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15.  
  16. #include "recio.h"
  17.  
  18. /* private macros */
  19. #define rflags(rp)       ((rp)->r_flags)
  20.  
  21. /* private module variables */
  22. static void (*_r_errfn)(REC *) = NULL; /* ptr to error function */
  23.  
  24. /****************************************************************************/
  25. char *                       /* returns pointer to field string             */
  26.     _rerrs(                  /* get field string if errfn() cleared error   */
  27.         REC *rp,             /* record pointer                              */
  28.         int  errnum)         /* error number                                */
  29. /****************************************************************************/
  30. {
  31.     char *fldp=NULL;         /* pointer to field string */
  32.  
  33.     if (!rseterr(rp, errnum)) fldp = rflds(rp);
  34.     return (fldp);
  35. }
  36.  
  37. /****************************************************************************/
  38. void                           /* returns nothing                           */
  39.     rseterrfn(                 /* registers a call-back error function      */
  40.         void(*rerrfn)(REC *rp))/* pointer to error function                 */
  41. /****************************************************************************/
  42. {
  43.     _r_errfn = rerrfn;         /* point to call back function */
  44. }
  45.  
  46. /****************************************************************************/
  47. void                         /* returns nothing                             */
  48.     rclearerr(               /* clears eof and error indicators             */
  49.         REC *rp)             /* record pointer                              */
  50. /****************************************************************************/
  51. {
  52.     if (risvalid(rp)) {
  53.         errno = 0;
  54.         rflags(rp) &= ~_R_EOF;
  55.         rflags(rp) &= ~(_R_ERR * _R_ERRMAX);
  56.     } else {
  57.         rseterr(NULL, EINVAL);
  58.     }
  59. }
  60.  
  61. /****************************************************************************/
  62. int                          /* returns error number (0=no error)           */
  63.     rerror(                  /* gets error number for record stream         */
  64.         REC *rp)             /* record pointer                              */
  65. /****************************************************************************/
  66. {
  67.     int errnum;              /* return error number */
  68.  
  69.     if (risvalid(rp)) {
  70.          errnum = rflags(rp) / _R_ERR;
  71.          errnum &= _R_ERRMAX;
  72.     } else {
  73.         errnum = rseterr(NULL, EINVAL);
  74.     }
  75.     return (errnum);
  76. }
  77.  
  78. /****************************************************************************/
  79. int                          /* returns possibly modified error number      */
  80.     rseterr(                 /* sets error number and calls error function  */
  81.         REC *rp,             /* record pointer                              */
  82.         int errnum)          /* error number                                */
  83. /****************************************************************************/
  84. {
  85.     /* if valid record pointer and stream error number clear */
  86.     if (risvalid(rp)) {
  87.         if (errnum > _R_ERRMAX) errnum = R_EINVAL;
  88.         if (!rerror(rp)) {
  89.  
  90.             /* set error number on stream */
  91.             rflags(rp) |= _R_ERR * errnum;
  92.  
  93.             /* invoke callback error function */
  94.             if (_r_errfn) _r_errfn(rp);
  95.  
  96.             /* find out if errfn() cleared error */
  97.             errnum = rerror(rp);
  98.         }
  99.  
  100.     /* else invalid record pointer */
  101.     } else {
  102.  
  103.         /* set global error number */
  104.         errno = errnum;
  105.  
  106.         /* invoke callback error function */
  107.         if (_r_errfn) _r_errfn(rp);
  108.  
  109.         /* find out if errfn() cleared error */
  110.         errnum = errno;
  111.     }
  112.  
  113.     /* if errfn cleared error, 0 returned */
  114.     return (errnum);
  115. }
  116.  
  117. /****************************************************************************/
  118. char *                       /* returns error message                       */
  119.     rstrerror(               /* gets error message for rerror number        */
  120.         int errnum)          /* error number                                */
  121. /****************************************************************************/
  122. {
  123.     switch (errnum) {
  124.     case 0:         return ("no error");
  125.     case R_EINVAL:  return ("invalid argument");
  126.     case R_EINVDAT: return ("invalid data");
  127.     case R_EINVMOD: return ("invalid mode");
  128.     case R_EMISDAT: return ("missing data");
  129.     case R_ENOMEM:  return ("out of memory");
  130.     case R_ENOPUT:  return ("unable to put data");
  131.     case R_ERANGE:  return ("data out of range");
  132.     }
  133.     return ("unknown error");
  134. }
  135.  
  136. /****************************************************************************/
  137. char *                       /* returns error message                       */
  138.     rerrstr(                 /* gets error message for record stream        */
  139.         REC *rp)             /* record pointer                              */
  140. /****************************************************************************/
  141. {
  142.     return (risvalid(rp) ? rstrerror(rerror(rp)) : rstrerror(R_EINVAL));
  143. }
  144.